Creating and Configuring Spring Beans

Course: Advanced Java Training

Topic: Creating and Configuring Spring Beans

Course Link: Advanced Java Training Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction to Spring Beans

A Spring Bean is an object that is instantiated, assembled, configured, or otherwise managed by the Spring IoC (Inversion of Control) container. Beans are the fundamental building blocks of applications developed using the Spring Framework.

In a traditional Java application, developers frequently create objects using the new keyword and manage their dependencies manually. In Spring, objects can be registered with the IoC container, which manages their creation, dependency injection, configuration, and applicable lifecycle callbacks.

For example, an e-commerce application may contain beans for customer services, product repositories, payment processing, email notifications, and database connections. Spring can manage these objects and connect them according to the application's configuration.

Example of a Simple Spring Bean

import org.springframework.stereotype.Component;

@Component
public class GreetingService {
    public void greet() {
        System.out.println("Welcome to Spring Framework!");
    }
}

The @Component annotation marks the class as a candidate for component scanning. When Spring scans the relevant package, it can register the class as a bean.

2. Learning Objectives

• Understand Spring beans and their role in Java applications.
• Learn different ways to create and register Spring beans.
• Configure beans using annotations, Java configuration, and XML.
• Understand bean naming, dependency injection, and bean scopes.
• Learn how to configure bean initialization and destruction.
• Understand component scanning and explicit bean registration.
• Identify common bean configuration errors and their solutions.
• Apply Spring bean configuration in a practical application.

3. What Is a Spring Bean?

A Spring Bean is an object whose configuration and lifecycle are managed by the Spring container. Spring uses bean definitions to determine how objects should be created and configured.

A bean definition can specify information such as the class, bean name, scope, constructor arguments, properties, dependencies, and lifecycle callbacks.

Example

public class StudentService {
    public void displayMessage() {
        System.out.println("Student service is running.");
    }
}

The class above is an ordinary Java class. It becomes a Spring-managed bean when it is registered with the container, for example through component scanning or a @Bean method.

Important Characteristics of Spring Beans

• Beans are managed by the Spring IoC container.
• Beans can receive dependencies through dependency injection.
• Beans can have different scopes, such as singleton or prototype.
• Beans can be configured using annotations, Java configuration, or XML.
• Spring can invoke configured initialization and destruction callbacks.
• Beans can be retrieved by name or type from the application context.

4. Understanding the Spring IoC Container

The Spring IoC container reads configuration metadata, creates bean instances, resolves dependencies, and manages their lifecycles. The two important container interfaces are BeanFactory and ApplicationContext.

How the Container Works

1. The developer defines bean configuration.
2. Spring reads bean definitions from the configured sources.
3. The container creates bean instances according to their scope and configuration.
4. Spring resolves the required dependencies.
5. Dependencies are injected into the appropriate beans.
6. Applicable initialization callbacks and bean post-processors run.
7. The application uses the configured beans.
8. Applicable destruction callbacks run when managed bean lifecycles end.

5. Different Ways to Create Spring Beans

Spring provides several approaches for registering beans. The most suitable approach depends on the application's architecture and the type of object being managed.

6. Creating Beans Using the @Component Annotation

The @Component annotation identifies a class as a candidate for Spring component scanning. When scanning is configured for the class's package, Spring can discover and register the class as a bean.

Example

package com.example.service;

import org.springframework.stereotype.Component;

@Component
public class MessageService {
    public void sendMessage() {
        System.out.println("Message sent successfully.");
    }
}

Using the Bean

package com.example;

import com.example.service.MessageService;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

@Configuration
@ComponentScan("com.example")
class AppConfig {
}

public class Main {
    public static void main(String[] args) {
        try (AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AppConfig.class)) {

            MessageService service =
                context.getBean(MessageService.class);

            service.sendMessage();
        }
    }
}

Expected output:

Message sent successfully.

Explanation: The container discovers MessageService through component scanning, creates the bean, and makes it available through the application context.

7. Creating Specialized Beans with Stereotype Annotations

Spring provides several stereotype annotations that describe the responsibility of a component. These annotations support component scanning and make application code easier to understand.

7.1 @Component

Used for general-purpose Spring-managed components.

@Component
public class UtilityService {
    public void execute() {
        System.out.println("Utility task executed.");
    }
}

7.2 @Service

Used to identify service-layer classes containing business logic.

import org.springframework.stereotype.Service;

@Service
public class CustomerService {
    public void registerCustomer() {
        System.out.println("Customer registered.");
    }
}

7.3 @Repository

Used to identify data-access components. In appropriate Spring persistence configurations, it also supports translation of certain persistence exceptions into Spring's data-access exception hierarchy.

import org.springframework.stereotype.Repository;

@Repository
public class CustomerRepository {
    public void saveCustomer() {
        System.out.println("Customer data saved.");
    }
}

7.4 @Controller

Used in Spring MVC applications to identify classes that handle web requests and return views or other response information.

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {
    @GetMapping("/home")
    public String home() {
        return "home";
    }
}

7.5 @RestController

Used to build REST endpoints. It combines controller behavior with response-body handling so that returned values are typically serialized into HTTP responses.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class StatusController {
    @GetMapping("/status")
    public String status() {
        return "Application is running.";
    }
}

8. Creating Beans Using @Configuration and @Bean

The @Configuration annotation marks a class as a source of bean definitions. Methods annotated with @Bean create objects that Spring registers and manages.

This approach is useful when you need to control object construction, configure third-party classes, or register classes that cannot be modified to add Spring annotations.

Example

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

class PaymentService {
    public void processPayment() {
        System.out.println("Payment processed successfully.");
    }
}

@Configuration
public class AppConfig {
    @Bean
    public PaymentService paymentService() {
        return new PaymentService();
    }
}

Here, the method returns a PaymentService instance, which Spring registers as a bean. By default, its bean name is the method name, paymentService.

Retrieving the Bean

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        try (AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AppConfig.class)) {

            PaymentService service =
                context.getBean(PaymentService.class);

            service.processPayment();
        }
    }
}

Expected output:

Payment processed successfully.

9. Configuring Bean Names

Every bean has one or more identifiers within its container. Bean names help developers retrieve beans by name and distinguish between multiple implementations.

Default Bean Name

@Configuration
public class AppConfig {
    @Bean
    public EmailService emailService() {
        return new EmailService();
    }
}

The default bean name is emailService, matching the method name.

Custom Bean Name

@Bean("primaryEmailService")
public EmailService emailService() {
    return new EmailService();
}

In this case, the bean can be retrieved using the name primaryEmailService.

Bean Aliases

@Bean(name = {"emailService", "notificationEmailService"})
public EmailService emailService() {
    return new EmailService();
}

Both identifiers refer to the same bean definition and, for the default singleton scope, the same managed instance.

Retrieving a Bean by Name

EmailService service =
    context.getBean("primaryEmailService", EmailService.class);

Best practice: Use meaningful and consistent bean names, especially when several implementations of the same interface exist.

10. Dependency Injection While Configuring Beans

Dependency Injection (DI) allows Spring to supply the objects required by a bean instead of requiring the bean to create those dependencies directly.

Example: Service and Repository

import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Repository
class ProductRepository {
    public void save() {
        System.out.println("Product saved to the database.");
    }
}

@Service
class ProductService {
    private final ProductRepository repository;

    public ProductService(ProductRepository repository) {
        this.repository = repository;
    }

    public void createProduct() {
        repository.save();
    }
}

With component scanning enabled for the package, Spring can create both beans and inject ProductRepository into ProductService.

Constructor Injection

Constructor injection is generally recommended for required dependencies because it makes dependencies explicit and supports immutable fields.

public class OrderService {
    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Setter Injection

Setter injection can be useful for optional dependencies that may be configured after object construction.

public class NotificationService {
    private EmailService emailService;

    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}

Field Injection

Field injection uses annotations such as @Autowired to inject a dependency directly into a field. Although available, it is generally less suitable than constructor injection for required dependencies because it hides dependencies and makes isolated testing more difficult.

11. Configuring Bean Dependencies with @Bean Methods

A @Bean method can declare parameters that represent dependencies. Spring resolves those parameters from the container and supplies them when invoking the method.

interface NotificationService {
    void sendNotification();
}

class EmailNotificationService implements NotificationService {
    @Override
    public void sendNotification() {
        System.out.println("Email notification sent.");
    }
}

class OrderService {
    private final NotificationService notificationService;

    public OrderService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void placeOrder() {
        System.out.println("Order placed.");
        notificationService.sendNotification();
    }
}

@Configuration
class OrderConfig {
    @Bean
    NotificationService notificationService() {
        return new EmailNotificationService();
    }

    @Bean
    OrderService orderService(NotificationService notificationService) {
        return new OrderService(notificationService);
    }
}

Spring resolves the NotificationService parameter and injects it into the OrderService bean. This keeps dependency configuration outside the business class.

12. Configuring Beans Using XML

Spring also supports XML-based bean configuration. XML is useful in legacy applications or projects that intentionally keep configuration separate from Java source code.

Java Class

package com.example;

public class GreetingService {
    public void greet() {
        System.out.println("Hello from an XML-configured bean.");
    }
}

XML Configuration File

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="greetingService"
          class="com.example.GreetingService"/>

</beans>

Loading XML Configuration

import com.example.GreetingService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        try (ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("beans.xml")) {

            GreetingService service =
                context.getBean("greetingService", GreetingService.class);

            service.greet();
        }
    }
}

The XML file must be available on the application's classpath. Spring reads the bean definition, creates the object, and makes it available through the context.

13. Understanding Spring Bean Scopes

A bean's scope determines how Spring creates and shares its instances. The correct scope depends on the component's purpose and whether it should be shared or created separately.

Singleton Bean Example

@Component
@Scope("singleton")
public class ApplicationService {
}

Singleton is the default scope for Spring beans. It does not mean that the object is a JVM-wide singleton; the instance is associated with its bean definition in a particular container.

Prototype Bean Example

@Component
@Scope("prototype")
public class TaskProcessor {
}

Each request to the container for this prototype bean creates a new instance. Spring does not automatically manage the complete destruction lifecycle of prototype instances after handing them to the caller.

14. Configuring Bean Initialization and Destruction

Spring provides lifecycle callbacks that let a bean perform setup after its dependencies have been supplied and cleanup when its managed lifecycle ends.

Using @PostConstruct and @PreDestroy

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Component;

@Component
public class DatabaseService {

    @PostConstruct
    public void initialize() {
        System.out.println("Database service initialized.");
    }

    public void executeQuery() {
        System.out.println("Executing database query.");
    }

    @PreDestroy
    public void cleanup() {
        System.out.println("Database service is shutting down.");
    }
}

For modern Spring applications using Jakarta APIs, these annotations come from jakarta.annotation. Older applications may use the corresponding javax.annotation package, depending on the Spring and Java versions.

@PostConstruct runs during bean initialization after dependency injection. @PreDestroy runs during managed bean shutdown when the relevant destruction lifecycle is supported and invoked.

Using initMethod and destroyMethod

@Configuration
public class AppConfig {

    @Bean(initMethod = "start", destroyMethod = "stop")
    public BackgroundService backgroundService() {
        return new BackgroundService();
    }
}

class BackgroundService {
    public void start() {
        System.out.println("Background service started.");
    }

    public void stop() {
        System.out.println("Background service stopped.");
    }
}

This approach is particularly useful when configuring classes that cannot be modified to add lifecycle annotations.

15. Lazy Initialization of Spring Beans

By default, singleton beans are generally created eagerly during application context initialization. Lazy initialization delays bean creation until the bean is first requested or needed as a dependency.

Example

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
@Lazy
public class ReportGenerator {
    public ReportGenerator() {
        System.out.println("ReportGenerator bean created.");
    }
}

With lazy initialization, the bean is not created at context startup solely because it is a singleton; it is created when requested or needed. A lazy bean may still be created at startup if an eager bean requires it as a dependency.

Benefits

• Can reduce startup work for selected beans.
• Can defer expensive object creation.
• May be useful for optional application features.

Limitations

• Some configuration errors may appear later when the bean is first requested.
• First-use latency may increase.
• It should not be used indiscriminately for every bean.

16. Conditional Bean Configuration and Profiles

Spring applications sometimes need different implementations for development, testing, and production. Profiles and conditional configuration allow the application to register beans according to its environment or configuration.

Using @Profile

import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Repository;

@Repository
@Profile("development")
public class InMemoryCustomerRepository {
}

The bean is registered when the development profile is active and the relevant component scanning or configuration is enabled.

Activating a Profile

A profile can be activated through application configuration or startup settings. For example, a Spring Boot application's configuration can include:

spring.profiles.active=development

Choose the correct profile configuration for each environment, and avoid putting production secrets directly into source code.

17. Configuring Multiple Beans of the Same Type

Sometimes an application has multiple implementations of the same interface. For example, a payment application might support both card payments and bank transfers. Spring needs a clear way to decide which bean should be injected.

Using @Primary

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

@Service
@Primary
public class CardPaymentService implements PaymentService {
    @Override
    public void pay() {
        System.out.println("Payment completed by card.");
    }
}

@Primary indicates a preferred candidate when multiple beans match a single-valued dependency and no stronger selection resolves the choice.

Using @Qualifier

@Service("bankPaymentService")
class BankPaymentService implements PaymentService {
    @Override
    public void pay() {
        System.out.println("Payment completed by bank transfer.");
    }
}

@Service
class CheckoutService {
    private final PaymentService paymentService;

    public CheckoutService(
            @Qualifier("bankPaymentService")
            PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

The qualifier identifies the intended bean. Ensure the required imports and all referenced classes are included in the application.

18. Configuring Properties in Spring Beans

Bean behavior may depend on configuration values such as application names, API endpoints, timeouts, or feature settings. Spring supports externalized configuration through property files and annotations such as @Value.

application.properties

application.name=StudentManagementSystem
application.message=Welcome to the application

Reading Properties

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class ApplicationInfo {

    @Value("${application.name}")
    private String applicationName;

    @Value("${application.message}")
    private String message;

    public void display() {
        System.out.println("Application: " + applicationName);
        System.out.println(message);
    }
}

Spring resolves the placeholders from the configured property sources. For groups of related settings in Spring Boot, @ConfigurationProperties is often a more structured alternative.

19. Common Errors in Spring Bean Configuration

20. Best Practices for Creating and Configuring Beans

• Use constructor injection for mandatory dependencies.
• Use stereotype annotations to express component responsibilities clearly.
• Use @Bean methods for explicit configuration and third-party classes.
• Keep bean names meaningful and consistent.
• Choose bean scopes according to the component's actual requirements.
• Keep singleton service beans stateless where possible, or manage shared mutable state carefully.
• Use profiles or externalized properties for environment-specific configuration.
• Avoid creating unmanaged duplicate objects when the application expects container-managed beans.
• Use qualifiers to make multiple-implementation selection explicit.
• Keep initialization callbacks short and avoid unnecessary network or database work during startup.
• Write unit tests using injected fake or mock dependencies.
• Review application startup errors and the nested exception messages when troubleshooting.

21. Practical Example: Student Management Application

This example demonstrates how Spring can register a repository and a service, inject the repository into the service, and execute a simple operation.

StudentRepository.java

package com.example.student;

import org.springframework.stereotype.Repository;

@Repository
public class StudentRepository {
    public void saveStudent(String name) {
        System.out.println("Student saved: " + name);
    }
}

StudentService.java

package com.example.student;

import org.springframework.stereotype.Service;

@Service
public class StudentService {
    private final StudentRepository repository;

    public StudentService(StudentRepository repository) {
        this.repository = repository;
    }

    public void registerStudent(String name) {
        repository.saveStudent(name);
        System.out.println("Registration completed.");
    }
}

AppConfig.java

package com.example.student;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.example.student")
public class AppConfig {
}

Main.java

package com.example.student;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        try (AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AppConfig.class)) {

            StudentService service =
                context.getBean(StudentService.class);

            service.registerStudent("Rahul");
        }
    }
}

Expected output:

Student saved: Rahul
Registration completed.

Explanation: Spring scans the package, registers the repository and service beans, and injects the repository through the service constructor. The main class retrieves the managed service from the application context.

22. Unit Testing Spring Bean Configuration

Testing bean configuration helps confirm that the application context starts successfully and the required beans can be retrieved.

Example Using JUnit and Spring Test

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.assertNotNull;

@SpringBootTest
class StudentServiceTest {

    @Autowired
    private StudentService studentService;

    @Test
    void studentServiceBeanIsCreated() {
        assertNotNull(studentService);
    }
}

This example is intended for a Spring Boot project with the relevant test dependencies and application configuration. It verifies that the service can be injected into the test context.

For simple business logic, a unit test that directly constructs the service with a fake repository can be faster than starting the full Spring context. Use context tests when verifying Spring configuration and wiring is the goal.

23. Practical Exercises

1. Create a class named EmployeeService and register it using @Component.
2. Create a DepartmentRepository class and register it using @Repository.
3. Inject the repository into a service using constructor injection.
4. Register a third-party utility class using a @Bean method.
5. Configure a bean with a custom name and retrieve it by name.
6. Create two implementations of the same interface and resolve the dependency using @Qualifier.
7. Configure a prototype-scoped bean and compare its instances with a singleton-scoped bean.
8. Use initialization and destruction callbacks to display lifecycle messages.
9. Move an application setting into application.properties and inject it into a bean.
10. Write a test that confirms a required service bean is available in the Spring context.

24. Interview Questions and Answers

Q1. What is a Spring Bean?

Answer: A Spring Bean is an object managed by the Spring IoC container, including its configured dependencies and applicable lifecycle.

Q2. How can you create a Spring Bean?

Answer: You can register beans through component scanning with annotations such as @Component and @Service, declare them using @Bean methods, or use XML configuration.

Q3. What is the difference between @Component and @Bean?

Answer: @Component marks a class for component scanning, while @Bean marks a method that returns an object to be managed by Spring.

Q4. What is the purpose of @Configuration?

Answer: It identifies a class as a source of bean definitions and supports Java-based Spring configuration.

Q5. What is the default scope of a Spring Bean?

Answer: The default scope is singleton, meaning one shared instance per bean definition per container.

Q6. What is prototype scope?

Answer: Prototype scope causes Spring to create a new instance each time the bean is requested from the container.

Q7. What is the purpose of @Autowired?

Answer: It enables Spring to resolve and inject a suitable dependency at a supported injection point. It is not generally necessary on a class's only constructor.

Q8. What is the difference between @Service and @Repository?

Answer: Both support component registration, but @Service communicates a business-service role, while @Repository communicates a data-access role and supports persistence exception translation where applicable.

Q9. How do you configure a custom bean name?

Answer: Use a custom value in the @Component annotation or provide a name through the @Bean annotation.

Q10. What are bean lifecycle callbacks?

Answer: They are methods invoked at relevant lifecycle stages, such as initialization and destruction. Examples include @PostConstruct, @PreDestroy, and configured initialization or destruction methods.

Q11. What does @Lazy do?

Answer: It requests lazy initialization so a bean is created when first needed rather than eagerly at startup, subject to its dependencies and configuration.

Q12. How can you resolve multiple beans of the same type?

Answer: Use @Qualifier to identify a specific bean or @Primary to mark a preferred candidate.

Q13. What is component scanning?

Answer: Component scanning allows Spring to discover eligible annotated classes in configured packages and register them as beans.

Q14. What is the difference between BeanFactory and ApplicationContext?

Answer: BeanFactory provides core bean management functionality, while ApplicationContext provides additional application services and is commonly used in Spring applications.

Q15. Why is constructor injection recommended?

Answer: It makes mandatory dependencies explicit, supports immutable fields, and simplifies unit testing.

25. Quick Revision Checklist

• Understand the definition and purpose of a Spring Bean.
• Know how the Spring IoC container manages bean definitions.
• Understand the difference between @Component and @Bean.
• Know the purpose of @Configuration and component scanning.
• Practice constructor-based dependency injection.
• Understand singleton, prototype, and web-specific scopes.
• Know how to assign bean names and resolve ambiguous dependencies.
• Understand lazy initialization and lifecycle callbacks.
• Practice property configuration and environment-specific profiles.
• Be able to diagnose common bean registration and dependency errors.

26. Conclusion

Creating and configuring Spring Beans is an essential skill for Java developers working with the Spring Framework. Beans allow application components to be managed consistently by the IoC container, while dependency injection connects those components without requiring every class to create its own dependencies.

Spring supports several bean registration approaches, including component scanning, Java configuration using @Bean, and XML configuration. Understanding bean names, scopes, dependencies, lifecycle callbacks, profiles, and configuration properties helps developers build maintainable and testable applications.

To learn more about Java development, Spring concepts, and enterprise application programming, explore the Advanced Java Training course at JustAcademy. You can also register for a course demo to learn more about the training program, or visit the JustAcademy website.